/*
 * To change this template, choose Tools | Templates
 * and open the template in the editor.
 */

package Verwaltung;

import Datenbank.*;
import Data.*;
import java.rmi.*;
import java.sql.*;
import java.util.*;
import java.sql.Date;
import java.sql.Time;
import java.sql.Timestamp;
/**
 *
 * @author Tobias
 */
public class VerwaltungImpl extends java.rmi.server.UnicastRemoteObject implements Verwaltung {

    private PersonMapper peMapper = null;
    private KalenderMapper kaMapper = null;
    private KalendereintragMapper keMapper = null;
    private TerminMapper teMapper = null;
    private AlarmMapper alMapper = null;
    private WiederholungMapper wiMapper = null;
    private ZugriffsberechtigungMapper zuMapper = null;


public VerwaltungImpl(PersonMapper personMapper, KalenderMapper kalenderMapper, KalendereintragMapper kalendereintragMapper, TerminMapper terminMapper, AlarmMapper alarmMapper, WiederholungMapper wiederholungMapper, ZugriffsberechtigungMapper zugriffsberechtigungMapper) throws RemoteException {

       super();
        this.peMapper = personMapper;
        this.kaMapper = kalenderMapper;
        this.keMapper = kalendereintragMapper;
        this.teMapper = terminMapper;
        this.zuMapper = zugriffsberechtigungMapper;
        this.alMapper = alarmMapper;
        this.wiMapper = wiederholungMapper;
}


// Alle PersonMethoden
    public Person createPerson(int person_id, String vorname, String nachname, String raum, String email, String telefon, String passwort) throws RemoteException {

        Person pe = new PersonImpl();
        pe.set_person_id(1);
        pe.set_vorname(vorname);
        pe.set_nachname(nachname);
        pe.set_raum(raum);
        pe.set_email(email);
        pe.set_telefon(telefon);
        pe.set_passwort(passwort);

      if (!pe.get_vorname().isEmpty() && !pe.get_nachname().isEmpty() && !pe.get_raum().isEmpty() && !pe.get_email().isEmpty() && !pe.get_telefon().isEmpty() && !pe.get_passwort().isEmpty() )
        return peMapper.insert(pe); //Speichert die Person


      else {
        throw new RemoteException("Bezeichnung ist leer oder schon vorhanden.");

      }
    }


//    public boolean compareFLbezeichnung(Fluglinie x) throws RemoteException {
//        Vector<Fluglinie> fl = this.flMapper.findAll_fluglinie();
//        Iterator itrPr = fl.iterator();
//
//        while (itrPr.hasNext()) {
//            Fluglinie flTemp = (Fluglinie) itrPr.next();
//
//            if (flTemp.get_bezeichnung().contentEquals(x.get_bezeichnung())) {
//                return false;
//            }
//        }
//        return true;
//    }
/**
     * Diese Methode speichert eine Änderung bei einer Person in der Datenbank
     * ab. Dabei wird überprüft ob die Bezeichnung bereits vorhanden ist und ansonsten
     * wird die Änderung gespeichert. Sollte die Bezeichnung vorhanden sein, wird eine Remote Exception geworfen.
     * @param x ist die geänderte Person
     * @return die geänderte Person wird auch wieder zurückgegeben und in die Datenbank gespeichert
     * @throws RemoteException
     */
    public Person updatePerson(int person_id, String vorname, String nachname, String raum, String email, String telefon, String passwort) throws RemoteException {

       Person pe = new PersonImpl();
        pe.set_person_id(person_id);
        pe.set_vorname(vorname);
        pe.set_nachname(nachname);
        pe.set_raum(raum);
        pe.set_email(email);
        pe.set_telefon(telefon);
        pe.set_passwort(passwort);

//       if (this.compareFLbezeichnung(fl) && !fl.get_bezeichnung().isEmpty())
        return peMapper.update(pe); //Speichert die geänderte Person


//        else {
//        throw new RemoteException("Bezeichnung ist leer oder schon vorhanden.");
//
//        }
    }


    /**
     * Die Methode löscht ein Person aus der Datenbank,
     * @param x die Person, welche gelöscht werden soll
     * @throws RemoteException
     */
 public void deletePerson(Person x)throws RemoteException {
//        try {
//            if (roMapper.existsZuordnung(x)==false) {
                peMapper.delete(x);
//            }else {
//                  throw new RemoteException("Der Person sind noch Rollen zugewiesen. Bitte erst Rollen entfernen");
//            }
//       }
//        catch (Exception ex) {
//            ex.printStackTrace();
//        }
 }


 public Vector <Person> getAll_Person()throws RemoteException  {
//     Vector<Person> PersonErgebnis = getAll_Person();
//     Vector personen = new Vector();
//
//    for ( Person test : PersonErgebnis ) {
//        if (test != null ) {
////            Es wird überprüft ob die Person einen Titel besitzt. Trifft dies nicht zu wird dieser
////            in der Combobox weggelassen.
////            if (test.get_titel().equals("no title")) {
////                inhalte.add(test.get_vorname() + "  " + test.get_name());
////            }
////            else
//                personen.add(test.get_vorname()+ " " + test.get_nachname());
//        }
//    }

        return peMapper.findAll_person();
    }

 public Person findbyid_Person(int id)throws RemoteException  {

        return peMapper.findbyid(id);
    }


// Alle KalenderMethoden
public Kalender createKalender(int kalender_id, String bezeichnung, int besitzer, int zugriffsberechtigte) throws RemoteException {

        Kalender ka = new KalenderImpl();
        ka.set_kalender_id(2);
        ka.set_bezeichnung(bezeichnung);
        ka.set_besitzer(besitzer);
        ka.set_zugriffsberechtigte(zugriffsberechtigte);
//        ka.set_kalendereintrag_id(kalendereintrag_id);


      if (!ka.get_bezeichnung().isEmpty())
        return kaMapper.insert(ka); //Speichert den Kalender


    else {
        throw new RemoteException("Bezeichnung ist leer oder schon vorhanden.");

        }
    }


//    public boolean compareFLbezeichnung(Fluglinie x) throws RemoteException {
//        Vector<Fluglinie> fl = this.flMapper.findAll_fluglinie();
//        Iterator itrPr = fl.iterator();
//
//        while (itrPr.hasNext()) {
//            Fluglinie flTemp = (Fluglinie) itrPr.next();
//
//            if (flTemp.get_bezeichnung().contentEquals(x.get_bezeichnung())) {
//                return false;
//            }
//        }
//        return true;
//    }
/**
     * Diese Methode speichert eine Änderung bei einem Kalender in der Datenbank
     * ab. Dabei wird überprüft ob die Bezeichnung bereits vorhanden ist und ansonsten
     * wird die Änderung gespeichert. Sollte die Bezeichnung vorhanden sein, wird eine Remote Exception geworfen.
     * @param x ist der geänderte Kalender
     * @return der geänderte Kalender wird auch wieder zurückgegeben und in die Datenbank gespeichert
     * @throws RemoteException
     */
    public Kalender updateKalender(int kalender_id, String bezeichnung, int besitzer, int zugriffsberechtigte) throws RemoteException {

       Kalender ka = new KalenderImpl();
       ka.set_kalender_id(2);
       ka.set_bezeichnung(bezeichnung);
       ka.set_besitzer(besitzer);
       ka.set_zugriffsberechtigte(zugriffsberechtigte);
//        ka.set_kalendereintrag_id(kalendereintrag_id);

//       if (this.compareFLbezeichnung(fl) && !fl.get_bezeichnung().isEmpty())
        return kaMapper.update(ka); //Speichert den geänderte Kalender


//        else {
//        throw new RemoteException("Bezeichnung ist leer oder schon vorhanden.");
//
//        }
    }


    /**
     * Die Methode löscht einen Kalender aus der Datenbank,
     * @param x der Kalender, welcher gelöscht werden soll
     * @throws RemoteException
     */
 public void deleteKalender(Kalender x)throws RemoteException {
//        try {
//            if (roMapper.existsZuordnung(x)==false) {
                kaMapper.delete(x);
//            }else {
//                  throw new RemoteException("Der Person sind noch Rollen zugewiesen. Bitte erst Rollen entfernen");
//            }
//       }
//        catch (Exception ex) {
//            ex.printStackTrace();
//        }
 }


 public Vector <Kalender> getAll_Kalender()throws RemoteException  {

        return kaMapper.findAll_kalender();
    }

 public Kalender findbyid_Kalender(int id)throws RemoteException  {

        return kaMapper.findbyid(id);
    }


 // Alle KalendereintragMethoden
public Kalendereintrag createKalendereintrag(int kalendereintrag_id, int kalender_id, Date start, Date ende, String titel, String ort, String beschreibung, String kategorie, int erstellt_von, boolean erinnerung) throws RemoteException {

        Kalendereintrag ke = new KalendereintragImpl();
        ke.set_kalendereintrag_id(2);
        ke.set_kalender_id(kalender_id);
        ke.set_start(start);
        ke.set_ende(ende);
        ke.set_titel(titel);
        ke.set_ort(ort);
        ke.set_beschreibung(beschreibung);
        ke.set_kategorie(kategorie);
        ke.set_erstellt_von(erstellt_von);
        ke.set_erinnerung(erinnerung);

      if (!ke.get_titel().isEmpty() && !ke.get_beschreibung().isEmpty() && !ke.get_kategorie().isEmpty())
        return keMapper.insert(ke); //Speichert den Kalendereintrag


    else {
        throw new RemoteException("Bezeichnung ist leer oder schon vorhanden.");

        }
    }


//    public boolean compareFLbezeichnung(Fluglinie x) throws RemoteException {
//        Vector<Fluglinie> fl = this.flMapper.findAll_fluglinie();
//        Iterator itrPr = fl.iterator();
//
//        while (itrPr.hasNext()) {
//            Fluglinie flTemp = (Fluglinie) itrPr.next();
//
//            if (flTemp.get_bezeichnung().contentEquals(x.get_bezeichnung())) {
//                return false;
//            }
//        }
//        return true;
//    }
/**
     * Diese Methode speichert eine Änderung bei einem Kalendereintrag in der Datenbank
     * ab. Dabei wird überprüft ob die Bezeichnung bereits vorhanden ist und ansonsten
     * wird die Änderung gespeichert. Sollte die Bezeichnung vorhanden sein, wird eine Remote Exception geworfen.
     * @param x ist der geänderte Kalender
     * @return der geänderte Kalender wird auch wieder zurückgegeben und in die Datenbank gespeichert
     * @throws RemoteException
     */
    public Kalendereintrag updateKalendereintrag(int kalendereintrag_id, int kalender_id, Date start, Date ende, String titel, String ort, String beschreibung, String kategorie, int erstellt_von, boolean erinnerung) throws RemoteException {

        Kalendereintrag ke = new KalendereintragImpl();
        ke.set_kalendereintrag_id(2);
        ke.set_kalender_id(kalender_id);
        ke.set_start(start);
        ke.set_ende(ende);
        ke.set_titel(titel);
        ke.set_ort(ort);
        ke.set_beschreibung(beschreibung);
        ke.set_kategorie(kategorie);
        ke.set_erstellt_von(erstellt_von);
        ke.set_erinnerung(erinnerung);

//       if (this.compareFLbezeichnung(fl) && !fl.get_bezeichnung().isEmpty())
        return keMapper.update(ke); //Speichert den geänderten Kalendereintrag


//        else {
//        throw new RemoteException("Bezeichnung ist leer oder schon vorhanden.");
//
//        }
    }


    /**
     * Die Methode löscht einen Kalendereintrag aus der Datenbank,
     * @param x der Kalender, welcher gelöscht werden soll
     * @throws RemoteException
     */
 public void deleteKalendereintrag(Kalendereintrag x)throws RemoteException {
//        try {
//            if (roMapper.existsZuordnung(x)==false) {
                keMapper.delete(x);
//            }else {
//                  throw new RemoteException("Der Person sind noch Rollen zugewiesen. Bitte erst Rollen entfernen");
//            }
//       }
//        catch (Exception ex) {
//            ex.printStackTrace();
//        }
 }


 public Vector <Kalendereintrag> getAll_Kalendereintrag()throws RemoteException  {

        return keMapper.findAll_kalendereintrag();
    }

 public Kalendereintrag findbyid_Kalendereintrag(int id)throws RemoteException  {

        return keMapper.findbyid(id);
    }


// Alle TerminMethoden
public Termin createTermin(int termin_id, int teilnehmer, int folgetermin) throws RemoteException {

        Termin te = new TerminImpl();
        te.set_termin_id(2);
        te.set_teilnehmer(teilnehmer);
        te.set_folgetermin(folgetermin);

//      if (!te.get_bezeichnung().isEmpty())
        return teMapper.insert(te); //Speichert den Termin
//
//
//    else {
//        throw new RemoteException("Bezeichnung ist leer oder schon vorhanden.");

//        }
    }


//    public boolean compareFLbezeichnung(Fluglinie x) throws RemoteException {
//        Vector<Fluglinie> fl = this.flMapper.findAll_fluglinie();
//        Iterator itrPr = fl.iterator();
//
//        while (itrPr.hasNext()) {
//            Fluglinie flTemp = (Fluglinie) itrPr.next();
//
//            if (flTemp.get_bezeichnung().contentEquals(x.get_bezeichnung())) {
//                return false;
//            }
//        }
//        return true;
//    }
/**
     * Diese Methode speichert eine Änderung bei einem Termin in der Datenbank
     * ab. Dabei wird überprüft ob die Bezeichnung bereits vorhanden ist und ansonsten
     * wird die Änderung gespeichert. Sollte die Bezeichnung vorhanden sein, wird eine Remote Exception geworfen.
     * @param x ist der geänderte Kalender
     * @return der geänderte Kalender wird auch wieder zurückgegeben und in die Datenbank gespeichert
     * @throws RemoteException
     */
    public Termin updateTermin(int termin_id, int teilnehmer, int folgetermin) throws RemoteException {

       Termin te = new TerminImpl();
       te.set_termin_id(2);
       te.set_teilnehmer(teilnehmer);
       te.set_folgetermin(folgetermin);

//       if (this.compareFLbezeichnung(fl) && !fl.get_bezeichnung().isEmpty())
        return teMapper.update(te); //Speichert den geänderten Termin


//        else {
//        throw new RemoteException("Bezeichnung ist leer oder schon vorhanden.");
//
//        }
    }


    /**
     * Die Methode löscht einen Termin aus der Datenbank,
     * @param x der Kalender, welcher gelöscht werden soll
     * @throws RemoteException
     */
 public void deleteTermin(Termin x)throws RemoteException {
//        try {
//            if (roMapper.existsZuordnung(x)==false) {
                teMapper.delete(x);
//            }else {
//                  throw new RemoteException("Der Person sind noch Rollen zugewiesen. Bitte erst Rollen entfernen");
//            }
//       }
//        catch (Exception ex) {
//            ex.printStackTrace();
//        }
 }


 public Vector <Termin> getAll_Termin()throws RemoteException  {

        return teMapper.findAll_termin();
    }

 public Termin findbyid_Termin(int id)throws RemoteException  {

        return teMapper.findbyid(id);
    }


 // Alle AlarmMethoden
public Alarm createAlarm(int alarm_id, int termin_id, int wiederholung_id) throws RemoteException {

        Alarm al = new AlarmImpl();
        al.set_alarm_id(2);
        al.set_termin_id(termin_id);
        al.set_wiederholung_id(wiederholung_id);

//      if (!te.get_bezeichnung().isEmpty())
        return alMapper.insert(al); //Speichert den Alarm
//
//
//    else {
//        throw new RemoteException("Bezeichnung ist leer oder schon vorhanden.");

//        }
    }


//    public boolean compareFLbezeichnung(Fluglinie x) throws RemoteException {
//        Vector<Fluglinie> fl = this.flMapper.findAll_fluglinie();
//        Iterator itrPr = fl.iterator();
//
//        while (itrPr.hasNext()) {
//            Fluglinie flTemp = (Fluglinie) itrPr.next();
//
//            if (flTemp.get_bezeichnung().contentEquals(x.get_bezeichnung())) {
//                return false;
//            }
//        }
//        return true;
//    }
/**
     * Diese Methode speichert eine Änderung bei einem Alarm in der Datenbank
     * ab. Dabei wird überprüft ob die Bezeichnung bereits vorhanden ist und ansonsten
     * wird die Änderung gespeichert. Sollte die Bezeichnung vorhanden sein, wird eine Remote Exception geworfen.
     * @param x ist der geänderte Kalender
     * @return der geänderte Kalender wird auch wieder zurückgegeben und in die Datenbank gespeichert
     * @throws RemoteException
     */
    public Alarm updateAlarm(int alarm_id, int termin_id, int wiederholung_id) throws RemoteException {

        Alarm al = new AlarmImpl();
        al.set_alarm_id(2);
        al.set_termin_id(termin_id);
        al.set_wiederholung_id(wiederholung_id);

//       if (this.compareFLbezeichnung(fl) && !fl.get_bezeichnung().isEmpty())
        return alMapper.update(al); //Speichert den geänderten Alarm


//        else {
//        throw new RemoteException("Bezeichnung ist leer oder schon vorhanden.");
//
//        }
    }


    /**
     * Die Methode löscht einen Alarm aus der Datenbank,
     * @param x der Kalender, welcher gelöscht werden soll
     * @throws RemoteException
     */
 public void deleteAlarm(Alarm x)throws RemoteException {
//        try {
//            if (roMapper.existsZuordnung(x)==false) {
                alMapper.delete(x);
//            }else {
//                  throw new RemoteException("Der Person sind noch Rollen zugewiesen. Bitte erst Rollen entfernen");
//            }
//       }
//        catch (Exception ex) {
//            ex.printStackTrace();
//        }
 }


 public Vector <Alarm> getAll_Alarm()throws RemoteException  {

        return alMapper.findAll_alarm();
    }

 public Alarm findbyid_Alarm(int id)throws RemoteException  {

        return alMapper.findbyid(id);
    }


 // Alle WiederholungMethoden
public Wiederholung createWiederholung(int wiederholung_id, int vorgaengertermin) throws RemoteException {

        Wiederholung wi = new WiederholungImpl();
        wi.set_wiederholung_id(2);
        wi.set_vorgaengertermin(vorgaengertermin);

//      if (!te.get_bezeichnung().isEmpty())
        return wiMapper.insert(wi); //Speichert den Alarm
//
//
//    else {
//        throw new RemoteException("Bezeichnung ist leer oder schon vorhanden.");

//        }
    }


//    public boolean compareFLbezeichnung(Fluglinie x) throws RemoteException {
//        Vector<Fluglinie> fl = this.flMapper.findAll_fluglinie();
//        Iterator itrPr = fl.iterator();
//
//        while (itrPr.hasNext()) {
//            Fluglinie flTemp = (Fluglinie) itrPr.next();
//
//            if (flTemp.get_bezeichnung().contentEquals(x.get_bezeichnung())) {
//                return false;
//            }
//        }
//        return true;
//    }
/**
     * Diese Methode speichert eine Änderung bei einer Wiederholung in der Datenbank
     * ab. Dabei wird überprüft ob die Bezeichnung bereits vorhanden ist und ansonsten
     * wird die Änderung gespeichert. Sollte die Bezeichnung vorhanden sein, wird eine Remote Exception geworfen.
     * @param x ist die geänderte Wiederholung
     * @return die geänderte Wiederholung wird auch wieder zurückgegeben und in die Datenbank gespeichert
     * @throws RemoteException
     */
    public Wiederholung updateWiederholung(int wiederholung_id, int vorgaengertermin) throws RemoteException {

        Wiederholung wi = new WiederholungImpl();
        wi.set_wiederholung_id(2);
        wi.set_vorgaengertermin(vorgaengertermin);

//       if (this.compareFLbezeichnung(fl) && !fl.get_bezeichnung().isEmpty())
        return wiMapper.update(wi); //Speichert den geänderten Alarm


//        else {
//        throw new RemoteException("Bezeichnung ist leer oder schon vorhanden.");
//
//        }
    }


    /**
     * Die Methode löscht eine Wiederholung aus der Datenbank,
     * @param x die Wiederholung, welche gelöscht werden soll
     * @throws RemoteException
     */
 public void deleteWiederholung(Wiederholung x)throws RemoteException {
//        try {
//            if (roMapper.existsZuordnung(x)==false) {
                wiMapper.delete(x);
//            }else {
//                  throw new RemoteException("Der Person sind noch Rollen zugewiesen. Bitte erst Rollen entfernen");
//            }
//       }
//        catch (Exception ex) {
//            ex.printStackTrace();
//        }
 }


 public Vector <Wiederholung> getAll_Wiederholung()throws RemoteException  {

        return wiMapper.findAll_wiederholung();
    }

 public Wiederholung findbyid_Wiederholung(int id)throws RemoteException  {

        return wiMapper.findbyid(id);
    }


  // Alle ZugriffsberechtigungMethoden
public Zugriffsberechtigung createZugriffsberechtigung(int zugriffsberechtigung_id, int person_id, int kalender_id, String berechtigungstyp) throws RemoteException {

        Zugriffsberechtigung zu = new ZugriffsberechtigungImpl();
        zu.set_zugriffsberechtigung_id(2);
        zu.set_person_id(person_id);
        zu.set_kalender_id(kalender_id);
        zu.set_berechtigungstyp(berechtigungstyp);

//      if (!te.get_bezeichnung().isEmpty())
        return zuMapper.insert(zu); //Speichert die Zugriffsberechtigung
//
//
//    else {
//        throw new RemoteException("Bezeichnung ist leer oder schon vorhanden.");

//        }
    }


//    public boolean compareFLbezeichnung(Fluglinie x) throws RemoteException {
//        Vector<Fluglinie> fl = this.flMapper.findAll_fluglinie();
//        Iterator itrPr = fl.iterator();
//
//        while (itrPr.hasNext()) {
//            Fluglinie flTemp = (Fluglinie) itrPr.next();
//
//            if (flTemp.get_bezeichnung().contentEquals(x.get_bezeichnung())) {
//                return false;
//            }
//        }
//        return true;
//    }
/**
     * Diese Methode speichert eine Änderung bei einer Zugriffsberechtigung in der Datenbank
     * ab. Dabei wird überprüft ob die Bezeichnung bereits vorhanden ist und ansonsten
     * wird die Änderung gespeichert. Sollte die Bezeichnung vorhanden sein, wird eine Remote Exception geworfen.
     * @param x ist die geänderte Zugriffsberechtigung
     * @return die geänderte Zugriffsberechtigung wird auch wieder zurückgegeben und in die Datenbank gespeichert
     * @throws RemoteException
     */
    public Zugriffsberechtigung updateZugriffsberechtigung(int zugriffsberechtigung_id, int person_id, int kalender_id, String berechtigungstyp) throws RemoteException {

        Zugriffsberechtigung zu = new ZugriffsberechtigungImpl();
        zu.set_zugriffsberechtigung_id(2);
        zu.set_person_id(person_id);
        zu.set_kalender_id(kalender_id);
        zu.set_berechtigungstyp(berechtigungstyp);

//       if (this.compareFLbezeichnung(fl) && !fl.get_bezeichnung().isEmpty())
        return zuMapper.update(zu); //Speichert die geänderte Zugriffsberechtigung


//        else {
//        throw new RemoteException("Bezeichnung ist leer oder schon vorhanden.");
//
//        }
    }


    /**
     * Die Methode löscht eine Zugriffsberechtigung aus der Datenbank,
     * @param x die Zugriffsberechtigung, welche gelöscht werden soll
     * @throws RemoteException
     */
 public void deleteZugriffsberechtigung(Zugriffsberechtigung x)throws RemoteException {
//        try {
//            if (roMapper.existsZuordnung(x)==false) {
                zuMapper.delete(x);
//            }else {
//                  throw new RemoteException("Der Person sind noch Rollen zugewiesen. Bitte erst Rollen entfernen");
//            }
//       }
//        catch (Exception ex) {
//            ex.printStackTrace();
//        }
 }


 public Vector <Zugriffsberechtigung> getAll_Zugriffsberechtigung()throws RemoteException  {

        return zuMapper.findAll_zugriffsberechtigung();
    }

 public Zugriffsberechtigung findbyid_Zugriffsberechtigung(int id)throws RemoteException  {

        return zuMapper.findbyid(id);
    }

}

